package com.bf.electroplating.controller.front;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.bf.electroplating.pojo.dto.MonitoringPointDataListDTO;
import com.bf.electroplating.pojo.dto.OutfallMonitoringQueryDTO;
import com.bf.electroplating.pojo.dto.frontPage.*;
import com.bf.electroplating.pojo.entity.ElectroplatingPoint;
import com.bf.electroplating.pojo.entity.RainfallOutletMonitoring;
import com.bf.electroplating.pojo.entity.WasteGasMonitoringLog;
import com.bf.electroplating.pojo.vo.OutfallMonitoringDialogVO;
import com.bf.electroplating.pojo.vo.ParkSumaryVO;
import com.bf.electroplating.pojo.vo.ResultVO;
import com.bf.electroplating.pojo.vo.home.*;
import com.bf.electroplating.pojo.vo.inflowManagement.InflowManagementVO;
import com.bf.electroplating.pojo.vo.wasteGasMonitoringVO.WasteGasMonitoringLogVO;
import com.bf.electroplating.service.IElectroplatingPointService;
import com.bf.electroplating.service.IEnterpriseOutfallService;
import com.bf.electroplating.service.IFrontEnterpriseService;
import com.bf.electroplating.service.IFrontHomeDataService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.text.DecimalFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;


/**
 * 前端首页数据控制器
 * 为环保管理驾驶舱提供统一的数据接口
 *
 * @author system
 * @since 2025-01-11
 */
@Slf4j
@RestController
@RequestMapping("/api/front/home")
@Tag(name = "前端首页数据", description = "环保管理驾驶舱数据接口")
public class FrontHomeDataController {

    @Autowired
    private IFrontHomeDataService frontHomeDataService;
    @Autowired
    private IEnterpriseOutfallService enterpriseOutfallService;
    @Resource
    private IElectroplatingPointService  iElectroplatingPointService;
    @Resource
    private IFrontEnterpriseService frontEnterpriseService;
    /**
     * 合规管理数据接口
     * 包含问题发现、线条总数、生产设施用电量监控等数据
     */
    @GetMapping("/compliance")
    @Operation(summary = "获取合规管理数据", description = "获取合规管理模块的所有数据，包括问题发现、线条总数、生产设施用电量监控等")
    public ResultVO<ComplianceDataVO> getComplianceData(@RequestParam(required = false,value = "companyId")String companyId) {
        try {
            log.info("获取合规管理数据");
            ComplianceDataVO complianceData = frontHomeDataService.getComplianceData(companyId);
            return ResultVO.ok(complianceData);
        } catch (Exception e) {
            log.error("获取合规管理数据失败", e);
            return ResultVO.fail("获取合规管理数据失败: " + e.getMessage());
        }
    }

    /**
     * 用电检测数据接口
     * 包含生产设施和废气处理设施的用电量监控数据
     */
    @GetMapping("/power-monitoring")
    @Operation(summary = "获取用电检测数据", description = "获取生产设施和废气处理设施的用电量监控数据")
    public ResultVO<PowerMonitoringDataVO> getPowerMonitoringData() {
        try {
            log.info("获取用电检测数据");
            PowerMonitoringDataVO powerData = frontHomeDataService.getPowerMonitoringData();
            return ResultVO.ok(powerData);
        } catch (Exception e) {
            log.error("获取用电检测数据失败", e);
            return ResultVO.fail("获取用电检测数据失败: " + e.getMessage());
        }
    }

    /**
     * 废气管控数据接口
     * 包含废气处理设施监控点位和状态信息
     */
    @GetMapping("/exhaust-gas-control")
    @Operation(summary = "获取废气管控数据", description = "获取废气处理设施监控点位和状态信息")
    public ResultVO<ExhaustGasControlDataVO> getExhaustGasControlData(@RequestParam(required = false,value = "companyId")String companyId) {
        try {
            log.info("获取废气管控数据");
            ExhaustGasControlDataVO exhaustGasData = frontHomeDataService.getExhaustGasControlData(companyId);
            return ResultVO.ok(exhaustGasData);
        } catch (Exception e) {
            log.error("获取废气管控数据失败", e);
            return ResultVO.fail("获取废气管控数据失败: " + e.getMessage());
        }
    }

    /**
     * 废气处理设施水质检测数据接口
     * 包含水质监测参数和达标率信息
     */
    @GetMapping("/water-quality-monitoring")
    @Operation(summary = "获取废气处理设施水质检测数据", description = "获取废气处理设施水质监测参数和达标率信息")
    public ResultVO<WaterQualityMonitoringDataVO> getWaterQualityMonitoringData() {
        try {
            log.info("获取废气处理设施水质检测数据");
            WaterQualityMonitoringDataVO waterQualityData = frontHomeDataService.getWaterQualityMonitoringData();
            return ResultVO.ok(waterQualityData);
        } catch (Exception e) {
            log.error("获取废气处理设施水质检测数据失败", e);
            return ResultVO.fail("获取废气处理设施水质检测数据失败: " + e.getMessage());
        }
    }




    /**
     * 预警管理数据接口
     * 包含预警统计和预警列表信息
     */
    @GetMapping("/warning-management")
    @Operation(summary = "获取预警管理数据", description = "获取预警统计和预警列表信息")
    public ResultVO<WarningManagementDataVO> getWarningManagementData(@RequestParam(value = "companyId",required = false) String companyId) {
        try {
            log.info("获取预警管理数据");
            WarningManagementDataVO warningData = frontHomeDataService.getWarningManagementData(companyId);
            return ResultVO.ok(warningData);
        } catch (Exception e) {
            log.error("获取预警管理数据失败", e);
            return ResultVO.fail("获取预警管理数据失败: " + e.getMessage());
        }
    }

    /**
     * 企业地图数据接口
     * 包含园区企业位置和基础信息
     */
    @GetMapping("/enterprise-map")
    @Operation(summary = "获取企业地图数据", description = "获取园区企业位置和基础信息")
    public ResultVO<EnterpriseMapDataVO> getEnterpriseMapData(@RequestParam(value = "companyId",required = false)String companyId) {
        try {
            log.info("获取企业地图数据");
            EnterpriseMapDataVO mapData = frontHomeDataService.getEnterpriseMapData(companyId);
            return ResultVO.ok(mapData);
        } catch (Exception e) {
            log.error("获取企业地图数据失败", e);
            return ResultVO.fail("获取企业地图数据失败: " + e.getMessage());
        }
    }


    /**
     * 企业地图数据接口
     * 包含园区企业位置和基础信息
     */
    @GetMapping("/enterprise-map-withChart")
    @Operation(summary = "获取企业地图数据-带图", description = "获取园区企业位置和基础信息-带图")
    public ResultVO<EnterpriseMapDataVO> getEnterpriseMapDataWithChart(@RequestParam(value = "companyId",required = false)String companyId) {
        try {
            log.info("获取企业地图数据");
            EnterpriseMapDataVO mapData = frontHomeDataService.getEnterpriseMapDataWithChart(companyId);
            return ResultVO.ok(mapData);
        } catch (Exception e) {
            log.error("获取企业地图数据失败", e);
            return ResultVO.fail("获取企业地图数据失败: " + e.getMessage());
        }
    }

    /**
     * 企业地图数据接口
     * 包含园区企业位置和基础信息
     */
    @GetMapping("/enterprise-detail")
    @Operation(summary = "获取企业地图详情--用于2分钟一次弹框", description = "获取企业地图详情--用于2分钟一次弹框")
    public ResultVO<List<EnterpriseDetailVO>> getEnterpriseDetail(@RequestParam(value = "companyId")String companyId) {
        try {
            log.info("获取企业地图数据");
            List<EnterpriseDetailVO> enterpriseDetailVOS=frontEnterpriseService.getEnterpriseDetail(companyId);
            return ResultVO.ok(enterpriseDetailVOS);
        } catch (Exception e) {
            log.error("获取企业地图数据失败", e);
            return ResultVO.fail("获取企业地图数据失败: " + e.getMessage());
        }
    }


    /**
     * 企业地图数据接口
     * 包含园区企业位置和基础信息
     */
    @GetMapping("/park-sumary")
    @Operation(summary = "园区概况", description = "园区概况")
    public ResultVO<ParkSumaryVO> parkSumary() {
        try {

            return ResultVO.ok(frontHomeDataService.parkSummary());
        } catch (Exception e) {
            log.error("获取企业地图数据失败", e);
            return ResultVO.fail("获取企业地图数据失败: " + e.getMessage());
        }
    }

    /**
     * 分质分流数据接口
     * 包含企业废水检测和污水处理厂监测数据
     */
    @GetMapping("/wastewater-separation")
    @Operation(summary = "获取分质分流数据", description = "获取企业废水检测和污水处理厂监测数据")
    public ResultVO<WastewaterSeparationDataVO> getWastewaterSeparationData() {
        try {
            log.info("获取分质分流数据");
            WastewaterSeparationDataVO separationData = frontHomeDataService.getWastewaterSeparationData();
            return ResultVO.ok(separationData);
        } catch (Exception e) {
            log.error("获取分质分流数据失败", e);
            return ResultVO.fail("获取分质分流数据失败: " + e.getMessage());
        }
    }


    /**
     * 雨排口信息数据接口
     * 包含园区雨排口和企业雨排口监测数据
     */
    @GetMapping("/rainfall-outlet")
    @Operation(summary = "获取雨排口信息数据", description = "获取园区雨排口和企业雨排口监测数据")
    public ResultVO<RainfallOutletDataVO> getRainfallOutletData(@RequestParam(value = "id",required = false)String id) {
        try {
            log.info("获取雨排口信息数据");
            RainfallOutletDataVO rainfallData = frontHomeDataService.getRainfallOutletData(id);
            return ResultVO.ok(rainfallData);
        } catch (Exception e) {
            log.error("获取雨排口信息数据失败", e);
            return ResultVO.fail("获取雨排口信息数据失败: " + e.getMessage());
        }
    }



    /**
     * 企业设备树数据接口
     * 包含企业-监控点-设备的三级树形结构
     */
    @GetMapping("/enterprise-device-tree")
    @Operation(summary = "获取企业设备树数据", description = "获取企业设备树数据，包含企业-监控点-设备的三级树形结构")
    public ResultVO<List<EnterpriseDeviceTreeVO>> getEnterpriseDeviceTree(@RequestParam(value ="companyId",required =  false)String companyId) {
        try {
            log.info("获取企业设备树数据");
            List<EnterpriseDeviceTreeVO> treeData = frontHomeDataService.getEnterpriseDeviceTree(companyId);
            return ResultVO.ok(treeData);
        } catch (Exception e) {
            log.error("获取企业设备树数据失败", e);
            return ResultVO.fail("获取企业设备树数据失败: " + e.getMessage());
        }
    }



    /**
     * 监测点详情数据接口
     * 包含监测点信息、该公司所有其他设备列表、设备电流时间折线图数据
     */
    @GetMapping("/monitoring-point-detail")
    @Operation(summary = "获取监测点详情数据", description = "获取监测点详情数据，包含监测点信息、该公司所有其他设备列表、设备电流时间折线图数据")
    public ResultVO<MonitoringPointDetailVO> getMonitoringPointDetail(
            @RequestParam("deviceId") String deviceId,
            @RequestParam(value = "dataTime",required = false) String dataTime) {
        try {
            log.info("获取监测点详情数据，设备ID: {}, 数据时间: {}", deviceId, dataTime);
            MonitoringPointDetailVO detailData = frontHomeDataService.getMonitoringPointDetail(deviceId, dataTime);
            return ResultVO.ok(detailData);
        } catch (Exception e) {
            log.error("获取监测点详情数据失败", e);
            return ResultVO.fail("获取监测点详情数据失败: " + e.getMessage());
        }
    }

    /**
     * 监测点数据列表接口
     * 根据设备ID和时间范围查询监测点历史数据
     */
    @PostMapping("/monitoring-point-data-list")
    @Operation(summary = "获取监测点数据列表", description = "根据设备ID和时间范围查询监测点历史数据，支持分页")
    public ResultVO<MonitoringPointDataListVO> getMonitoringPointDataList(
         @RequestBody MonitoringPointDataListDTO monitoringPointDataListDTO ) {
        try {
            MonitoringPointDataListVO dataList = frontHomeDataService.getMonitoringPointDataList(
                    monitoringPointDataListDTO.getId(), monitoringPointDataListDTO.getStartTime(),
                    monitoringPointDataListDTO.getEndTime(), monitoringPointDataListDTO.getPageNum(), monitoringPointDataListDTO.getPageSize());
            return ResultVO.ok(dataList);
        } catch (Exception e) {
            log.error("获取监测点数据列表失败", e);
            return ResultVO.fail("获取监测点数据列表失败: " + e.getMessage());
        }
    }

    /**
     * 企业检测因子树接口
     * 包含企业-检测因子的二级树形结构
     */
//    @GetMapping("/company-factor-tree")
//    @Operation(summary = "获取企业检测因子树数据", description = "获取企业检测因子树数据，包含企业-检测因子的二级树形结构")
//    public ResultVO<List<CompanyFactorTreeVO>> getCompanyFactorTree() {
//        try {
//            log.info("获取企业检测因子树数据");
//            List<CompanyFactorTreeVO> treeData = frontHomeDataService.getCompanyFactorTree();
//            return ResultVO.ok(treeData);
//        } catch (Exception e) {
//            log.error("获取企业检测因子树数据失败", e);
//            return ResultVO.fail("获取企业检测因子树数据失败: " + e.getMessage());
//        }
//    }

    /**
     * 企业废水类型树接口
     * 包含企业-废水类型的二级树形结构
     */
    @GetMapping("/company-wastewater-tree")
    @Operation(summary = "获取企业废水类型树数据", description = "获取企业废水类型树数据，包含企业-废水类型的二级树形结构")
    public ResultVO<List<CompanyWastewaterTreeVO>> getCompanyWastewaterTree() {
        try {
            log.info("获取企业废水类型树数据");
            List<CompanyWastewaterTreeVO> treeData = frontHomeDataService.getCompanyWastewaterTree();
            return ResultVO.ok(treeData);
        } catch (Exception e) {
            log.error("获取企业废水类型树数据失败", e);
            return ResultVO.fail("获取企业废水类型树数据失败: " + e.getMessage());
        }
    }

    /**
     * 企业废气树接口
     * 包含企业-设备的二级树形结构
     */
    @GetMapping("/company-waste-gas-tree")
    @Operation(summary = "获取企业废气树数据", description = "获取企业废气树数据，包含企业-设备的二级树形结构")
    public ResultVO<List<CompanyWasteGasTreeVO>> getCompanyWasteGasTree(@RequestParam(value = "companyId",required = false)String companyId) {
        try {
            log.info("获取企业废气树数据");
            List<CompanyWasteGasTreeVO> treeData = frontHomeDataService.getCompanyWasteGasTree(companyId);
            return ResultVO.ok(treeData);
        } catch (Exception e) {
            log.error("获取企业废气树数据失败", e);
            return ResultVO.fail("获取企业废气树数据失败: " + e.getMessage());
        }
    }

    /**
     * 企业废气树接口
     * 包含企业-设备的二级树形结构
     */
    @GetMapping("/company-rain-tree")
    @Operation(summary = "获取企业雨排口树", description = "获取企业废气树数据，包含企业-设备的二级树形结构")
    public ResultVO<List<CompanyRainTreeVO>> getCompanyRainTree() {
        try {
            log.info("获取企业雨排口树");
            List<CompanyRainTreeVO> treeData = frontHomeDataService.getCompanyRainTree();
            return ResultVO.ok(treeData);
        } catch (Exception e) {
            log.error("获取企业雨排口树数据失败", e);
            return ResultVO.fail("获取企业雨排口树数据失败: " + e.getMessage());
        }
    }

    /**
     * 污水厂树接口
     * 包含污水厂-出水口类型的二级树形结构
     */
    @GetMapping("/sewage-plant-tree")
    @Operation(summary = "获取污水厂树", description = "获取污水厂树数据，包含污水厂-出水口类型的二级树形结构")
    public ResultVO<List<SewagePlantTreeVO>> getSewagePlantTree() {
        try {
            log.info("获取污水厂树");
            List<SewagePlantTreeVO> treeData = frontHomeDataService.getSewagePlantTree();
            return ResultVO.ok(treeData);
        } catch (Exception e) {
            log.error("获取污水厂树数据失败", e);
            return ResultVO.fail("获取污水厂树数据失败: " + e.getMessage());
        }
    }

    /**
     * 污水厂数据详情接口
     * 根据污水厂名称和时间段查询污水厂运行数据详情
     */
    @PostMapping("/sewage-plant-detail")
    @Operation(summary = "获取污水厂数据详情", description = "根据污水厂名称和时间段查询污水厂运行数据详情，包含运行数据和图表数据")
    public ResultVO<SewagePlantDetailVO> getSewagePlantDetail(
            @RequestBody SewagePlantDetailDTO sewagePlantDetailDTO) {
        try {
            log.info("获取污水厂数据详情，污水厂名称: {}, 出水口类型: {}, 开始时间: {}, 结束时间: {}", 
                    sewagePlantDetailDTO.getPlantCode(), sewagePlantDetailDTO.getOutletType(), 
                    sewagePlantDetailDTO.getStartTime(), sewagePlantDetailDTO.getEndTime());
            SewagePlantDetailVO detailData = frontHomeDataService.getSewagePlantDetail(sewagePlantDetailDTO);
            return ResultVO.ok(detailData);
        } catch (Exception e) {
            log.error("获取污水厂数据详情失败", e);
            return ResultVO.fail("获取污水厂数据详情失败: " + e.getMessage());
        }
    }

    /**
     * 污水厂排水口运行列表接口
     * 根据污水厂编码和时间段查询污水厂排水口运行数据列表
     */
    @PostMapping("/sewage-plant-list")
    @Operation(summary = "获取污水厂排水口运行列表", description = "根据污水厂编码和时间段查询污水厂排水口运行数据列表，支持分页")
    public ResultVO<Page<SewagePlantListVO>> getSewagePlantList(
            @RequestBody SewagePlantListDTO sewagePlantListDTO) {
        try {
            log.info("获取污水厂排水口运行列表，污水厂编码: {}, 出水口类型: {}, 开始时间: {}, 结束时间: {}", 
                    sewagePlantListDTO.getPlantCode(), sewagePlantListDTO.getOutletType(), 
                    sewagePlantListDTO.getStartTime(), sewagePlantListDTO.getEndTime());
            Page<SewagePlantListVO> listData = frontHomeDataService.getSewagePlantList(sewagePlantListDTO);
            return ResultVO.ok(listData);
        } catch (Exception e) {
            log.error("获取污水厂排水口运行列表失败", e);
            return ResultVO.fail("获取污水厂排水口运行列表失败: " + e.getMessage());
        }
    }

    /**
     * 废气处理设施详情接口
     * 根据企业ID和时间段查询废气处理设施运行数据详情
     */
    @PostMapping("/rainfall-outlet-hisdata-list")
    @Operation(summary = "园区雨排口历史数据列表", description = "园区雨排口历史数据列表")
    public ResultVO<EnterpriseOutletSummaryVO> RainFallOutletHisDataList(
            @RequestBody RainFallOutletHisDataDTO rainFallOutletHisDataDTO) {
        try {
            return ResultVO.ok(frontHomeDataService.enterpriseOutletSummaryVO(rainFallOutletHisDataDTO));

        } catch (Exception e) {
            log.error("园区雨排口历史数据列表失败", e);
            return ResultVO.fail("园区雨排口历史数据列表失败: " + e.getMessage());
        }
    }


    /**
     * 废气处理设施详情接口
     * 根据企业ID和时间段查询废气处理设施运行数据详情
     */
    @PostMapping("/waste-gas-detail")
    @Operation(summary = "获取废气处理设施详情", description = "根据企业ID和时间段查询废气处理设施运行数据详情，包含运行数据和图表数据")
    public ResultVO<WasteGasDetailVO> getWasteGasDetail(
            @RequestBody WasteGasDetailDTO wasteGasDetailDTO) {
        try {
            log.info("获取废气处理设施详情，企业ID: {}, 开始时间: {}, 结束时间: {}", 
                    wasteGasDetailDTO.getCompanyId(), wasteGasDetailDTO.getStartTime());
            WasteGasDetailVO detailData = frontHomeDataService.getWasteGasDetail(
                    wasteGasDetailDTO.getCompanyId(),wasteGasDetailDTO.getItemId(), wasteGasDetailDTO.getStartTime());
            return ResultVO.ok(detailData);
        } catch (Exception e) {
            log.error("获取废气处理设施详情失败", e);
            return ResultVO.fail("获取废气处理设施详情失败: " + e.getMessage());
        }
    }

    @PostMapping("/dialog-data")
    @Operation(summary = "获取排污口监测弹框数据", description = "获取排污口监测弹框数据，包含左侧雷达图当前数据和右侧历史数据表格")
    public ResultVO<OutfallMonitoringDialogVO> getOutfallMonitoringDialogData(
            @RequestBody OutfallMonitoringQueryDTO queryDTO) {
        try {
            log.info("获取排污口监测弹框数据，查询条件: {}", queryDTO);

            if (queryDTO == null) {
                queryDTO = new OutfallMonitoringQueryDTO();
            }

            // 设置默认分页参数
            if (queryDTO.getPageNum() == null || queryDTO.getPageNum() <= 0) {
                queryDTO.setPageNum(1);
            }
            if (queryDTO.getPageSize() == null || queryDTO.getPageSize() <= 0) {
                queryDTO.setPageSize(10);
            }

            OutfallMonitoringDialogVO dialogData = enterpriseOutfallService.getOutfallMonitoringDialogData(queryDTO);
            return ResultVO.ok(dialogData);
        } catch (Exception e) {
            log.error("获取排污口监测弹框数据失败", e);
            return ResultVO.fail("获取排污口监测弹框数据失败: " + e.getMessage());
        }
    }

    /**
     * 废气处理设施详情接口
     * 根据企业ID和时间段查询废气处理设施运行数据详情
     */
    @PostMapping("/waste-gas-list")
    @Operation(summary = "获取废气处理设施历史数据列表", description = "获取废气处理设施历史数据列表")
    public ResultVO<Page<WasteGasMonitoringLogVO>> getWasteGasList(
            @RequestBody WasteGasDetailDTO wasteGasDetailDTO) {
        try {
            log.info("获取废气处理设施详情，企业ID: {}, 开始时间: {}, 结束时间: {}",
                    wasteGasDetailDTO.getCompanyId(), wasteGasDetailDTO.getStartTime(), wasteGasDetailDTO.getEndTime());
            Page<WasteGasMonitoringLogVO> detailData = frontHomeDataService.getWasteGasList(
                    wasteGasDetailDTO.getCompanyId(),wasteGasDetailDTO.getItemId(), wasteGasDetailDTO.getStartTime(), wasteGasDetailDTO.getEndTime()
            ,wasteGasDetailDTO.getPageNum(),wasteGasDetailDTO.getPageSize());
            return ResultVO.ok(detailData);
        } catch (Exception e) {
            log.error("获取废气处理设施详情失败", e);
            return ResultVO.fail("获取废气处理设施详情失败: " + e.getMessage());
        }
    }


    /**
     * 企业预排口运行详情接口
     * 根据企业ID和时间段查询预排口运行数据详情
     */
    @PostMapping("/pre-discharge-detail")
    @Operation(summary = "获取企业预排口运行详情", description = "根据企业ID和时间段查询预排口运行数据详情，包含运行数据和图表数据")
    public ResultVO<PreDischargeDetailVO> getPreDischargeDetail(
            @RequestBody PreDischargeDetailDTO preDischargeDetailDTO) {

        try {
            PreDischargeDetailVO detailData = frontHomeDataService.getPreDischargeDetail(preDischargeDetailDTO
                    .getCompanyId(),preDischargeDetailDTO.getWaterId(), preDischargeDetailDTO.getStartTime(),
                    preDischargeDetailDTO.getEndTime());
            return ResultVO.ok(detailData);
        } catch (Exception e) {
            log.error("获取企业预排口运行详情失败", e);
            return ResultVO.fail("获取企业预排口运行详情失败: " + e.getMessage());
        }
    }

    @PostMapping("/pre-discharge-list")
    @Operation(summary = "获取企业预排口运行列表", description = "根据企业ID和时间段查询预排口运行数据详情，包含运行数据和图表数据")
    public ResultVO<Page<InflowManagementVO>> getPreDischargeList(
            @RequestBody PreDischargeDetailDTO preDischargeDetailDTO) {

        try {
            Page<InflowManagementVO> detailData = frontHomeDataService.getPreDischargeList(preDischargeDetailDTO
                            .getCompanyId(),preDischargeDetailDTO.getWaterId(), preDischargeDetailDTO.getStartTime(),
                    preDischargeDetailDTO.getEndTime(),preDischargeDetailDTO.getPageNum(),preDischargeDetailDTO.getPageSize());
            return ResultVO.ok(detailData);
        } catch (Exception e) {
            log.error("获取企业预排口运行列表失败", e);
            return ResultVO.fail("获取企业预排口运行列表失败: " + e.getMessage());
        }
    }

    @GetMapping("/electroplatingPointeList")
    @Operation(summary = "获取电镀点位列表", description = "获取电镀点位列表")
    public ResultVO<ElectroplatingPointVO> getElectroplatingPoint(@RequestParam(value = "companyId",required = false)String companyId) {

        try {
            LambdaQueryWrapper<ElectroplatingPoint> queryWrapper = new LambdaQueryWrapper<>();
            if (!StringUtils.isEmpty(companyId)) {
                queryWrapper.eq(ElectroplatingPoint::getCompanyId, companyId);
            }
            List<ElectroplatingPoint> electroplatingPoints=iElectroplatingPointService.list(queryWrapper);
            Map<String, List<ElectroplatingPoint>> map = electroplatingPoints.stream().collect(Collectors.groupingBy(ElectroplatingPoint::getCompanyName));
            ElectroplatingPointVO electroplatingPointVOS=new ElectroplatingPointVO();
            List<List<Map<String,Object>>> electroplatingPointList=new ArrayList<>();
            for (String Key : map.keySet()) {
                List<ElectroplatingPoint> temp=map.get(Key).stream().sorted(Comparator.comparing(ElectroplatingPoint::getSort)).collect(Collectors.toList());
                List<Map<String,Object>> thisMap=new ArrayList<>();
                for(ElectroplatingPoint electroplatingPoint:temp){
                    Map<String,Object> map1=new HashMap<>();
                    DecimalFormat df = new DecimalFormat("0.000000");

                    map1.put("latitude",df.format(electroplatingPoint.getLatitude()));
                    map1.put("longitude",df.format(electroplatingPoint.getLongitude()));
                    thisMap.add(map1);
                }
                electroplatingPointList.add(thisMap);
            }
            electroplatingPointVOS.setElectroplatingPointList(electroplatingPointList);
                      return ResultVO.ok(electroplatingPointVOS);
        } catch (Exception e) {
            log.error("获取电镀点位列表失败", e);
            return ResultVO.fail("获取电镀点位列表失败: " + e.getMessage());
        }
    }

    /**
     * 雨水数据查询接口
     * 根据企业名称和时间段查询雨水数据
     */
    @PostMapping("/rainfall-data-list")
    @Operation(summary = "获取雨水数据列表", description = "根据企业名称和时间段查询雨水数据，支持分页和天气筛选")
    public ResultVO<Page<RainfallDataVO>> getRainfallDataList(
            @RequestBody RainfallDataQueryDTO rainfallDataQueryDTO) {
        try {
            log.info("获取雨水数据列表，企业名称: {}, 开始时间: {}, 结束时间: {}", 
                    rainfallDataQueryDTO.getCompanyId(), rainfallDataQueryDTO.getStartTime(), rainfallDataQueryDTO.getEndTime());
            Page<RainfallDataVO> rainfallData = frontHomeDataService.getRainfallDataList(rainfallDataQueryDTO);
            return ResultVO.ok(rainfallData);
        } catch (Exception e) {
            log.error("获取雨水数据列表失败", e);
            return ResultVO.fail("获取雨水数据列表失败: " + e.getMessage());
        }
    }

    /**
     * 月度数据统计接口
     * 根据企业ID和时间段查询月度统计数据
     */
    @PostMapping("/monthly-stats-list")
    @Operation(summary = "获取月度数据统计列表", description = "根据企业ID和时间段查询月度统计数据，支持分页")
    public ResultVO<Page<MonthlyStatsVO>> getMonthlyStatsList(
            @RequestBody MonthlyStatsQueryDTO monthlyStatsQueryDTO) {
        try {
            log.info("获取月度数据统计列表，企业ID: {}, 开始时间: {}, 结束时间: {}", 
                    monthlyStatsQueryDTO.getCompanyId(), monthlyStatsQueryDTO.getStartTime(), monthlyStatsQueryDTO.getEndTime());
            Page<MonthlyStatsVO> monthlyStats = frontHomeDataService.getMonthlyStatsList(monthlyStatsQueryDTO);
            return ResultVO.ok(monthlyStats);
        } catch (Exception e) {
            log.error("获取月度数据统计列表失败", e);
            return ResultVO.fail("获取月度数据统计列表失败: " + e.getMessage());
        }
    }

    /**
     * 月度统计趋势图接口
     * 根据企业ID和时间段查询月度统计趋势图数据
     */
    @PostMapping("/monthly-stats-chart")
    @Operation(summary = "获取月度统计趋势图数据", description = "根据企业ID和时间段查询月度统计趋势图数据，包含最大值、最小值、平均值")
    public ResultVO<MonthlyChartVO> getMonthlyStatsChart(
            @RequestBody MonthlyStatsQueryDTO monthlyStatsQueryDTO) {
        try {
            log.info("获取月度统计趋势图数据，企业ID: {}, 开始时间: {}, 结束时间: {}", 
                    monthlyStatsQueryDTO.getCompanyId(), monthlyStatsQueryDTO.getStartTime(), monthlyStatsQueryDTO.getEndTime());
            MonthlyChartVO chartData = frontHomeDataService.getMonthlyStatsChart(monthlyStatsQueryDTO);
            return ResultVO.ok(chartData);
        } catch (Exception e) {
            log.error("获取月度统计趋势图数据失败", e);
            return ResultVO.fail("获取月度统计趋势图数据失败: " + e.getMessage());
        }
    }

    /**
     * 电导率趋势图接口
     * 根据企业ID和时间段查询电导率趋势图数据
     */
    @PostMapping("/conductivity-trend-chart")
    @Operation(summary = "获取电导率趋势图数据", description = "根据企业ID和时间段查询电导率趋势图数据")
    public ResultVO<MonthlyChartVO> getConductivityTrendChart(
            @RequestBody MonthlyStatsQueryDTO monthlyStatsQueryDTO) {
        try {
            log.info("获取电导率趋势图数据，企业ID: {}, 开始时间: {}, 结束时间: {}", 
                    monthlyStatsQueryDTO.getCompanyId(), monthlyStatsQueryDTO.getStartTime(), monthlyStatsQueryDTO.getEndTime());
            MonthlyChartVO chartData = frontHomeDataService.getConductivityTrendChart(monthlyStatsQueryDTO);
            return ResultVO.ok(chartData);
        } catch (Exception e) {
            log.error("获取电导率趋势图数据失败", e);
            return ResultVO.fail("获取电导率趋势图数据失败: " + e.getMessage());
        }
    }

//    /**
//     * 电导率趋势图接口
//     * 根据企业ID和时间段查询电导率趋势图数据
//     */
//    @PostMapping("/conductivity-trend-chart")
//    @Operation(summary = "获取电导率趋势图数据", description = "根据企业ID和时间段查询电导率趋势图数据")
//    public ResultVO<MonthlyChartVO> getConductivityTrendChart(
//            @RequestBody MonthlyStatsQueryDTO monthlyStatsQueryDTO) {
//        try {
//            log.info("获取电导率趋势图数据，企业ID: {}, 开始时间: {}, 结束时间: {}",
//                    monthlyStatsQueryDTO.getCompanyId(), monthlyStatsQueryDTO.getStartTime(), monthlyStatsQueryDTO.getEndTime());
//            MonthlyChartVO chartData = frontHomeDataService.getConductivityTrendChart(monthlyStatsQueryDTO);
//            return ResultVO.ok(chartData);
//        } catch (Exception e) {
//            log.error("获取电导率趋势图数据失败", e);
//            return ResultVO.fail("获取电导率趋势图数据失败: " + e.getMessage());
//        }
//    }

    /**
     * 偷漏排列表接口
     * 根据企业ID和时间段查询疑似偷排漏排记录
     */
    @PostMapping("/suspected-discharge-list")
    @Operation(summary = "获取偷漏排列表", description = "根据企业ID和时间段查询疑似偷排漏排记录，支持分页和筛选")
    public ResultVO<Page<SuspectedDischargeVO>> getSuspectedDischargeList(
            @RequestBody SuspectedDischargeQueryDTO suspectedDischargeQueryDTO) {
        try {
            log.info("获取偷漏排列表，企业ID: {}, 开始时间: {}, 结束时间: {}", 
                    suspectedDischargeQueryDTO.getCompanyId(), suspectedDischargeQueryDTO.getStartTime(), suspectedDischargeQueryDTO.getEndTime());
            Page<SuspectedDischargeVO> suspectedDischargeList = frontHomeDataService.getSuspectedDischargeList(suspectedDischargeQueryDTO);
            return ResultVO.ok(suspectedDischargeList);
        } catch (Exception e) {
            log.error("获取偷漏排列表失败", e);
            return ResultVO.fail("获取偷漏排列表失败: " + e.getMessage());
        }
    }
}
